﻿#region Assembly mscorlib.dll, v4.0.30319
// C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\Profile\Client\mscorlib.dll
#endregion

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Security;

namespace System.Security.Policy
{
    // Summary:
    //     Defines the set of information that constitutes input to security policy
    //     decisions. This class cannot be inherited.
    //[Serializable]
    [ComVisible(true)]
    public sealed class Evidence : ICollection, IEnumerable
    {
        // Summary:
        //     Initializes a new empty instance of the System.Security.Policy.Evidence class.
        public Evidence()
        {
        }

        //
        // Summary:
        //     Initializes a new instance of the System.Security.Policy.Evidence class from
        //     a shallow copy of an existing one.
        //
        // Parameters:
        //   evidence:
        //     The System.Security.Policy.Evidence instance from which to create the new
        //     instance. This instance is not deep-copied.
        //
        // Exceptions:
        //   System.ArgumentException:
        //     The evidence parameter is not a valid instance of System.Security.Policy.Evidence.
        public Evidence(Evidence evidence)
        {
        }

        //
        // Summary:
        //     Initializes a new instance of the System.Security.Policy.Evidence class from
        //     multiple sets of host and assembly evidence.
        //
        // Parameters:
        //   hostEvidence:
        //     The host evidence from which to create the new instance.
        //
        //   assemblyEvidence:
        //     The assembly evidence from which to create the new instance.
        public Evidence(EvidenceBase[] hostEvidence, EvidenceBase[] assemblyEvidence)
        {
        }

        //
        // Summary:
        //     Initializes a new instance of the System.Security.Policy.Evidence class from
        //     multiple sets of host and assembly evidence.
        //
        // Parameters:
        //   hostEvidence:
        //     The host evidence from which to create the new instance.
        //
        //   assemblyEvidence:
        //     The assembly evidence from which to create the new instance.
        [Obsolete("This constructor is obsolete. Please use the constructor which takes arrays of EvidenceBase instead.")]
        public Evidence(object[] hostEvidence, object[] assemblyEvidence)
        {
        }

        // Summary:
        //     Gets the number of evidence objects in the evidence set.
        //
        // Returns:
        //     The number of evidence objects in the evidence set.
        [Obsolete("Evidence should not be treated as an ICollection. Please use GetHostEnumerator and GetAssemblyEnumerator to iterate over the evidence to collect a count.")]
        public int Count { get; set; }
        //
        // Summary:
        //     Gets a value indicating whether the evidence set is read-only.
        //
        // Returns:
        //     Always false, because read-only evidence sets are not supported.
        public bool IsReadOnly { get; set; }
        //
        // Summary:
        //     Gets a value indicating whether the evidence set is thread-safe.
        //
        // Returns:
        //     Always false because thread-safe evidence sets are not supported.
        public bool IsSynchronized { get; set; }
        //
        // Summary:
        //     Gets or sets a value indicating whether the evidence is locked.
        //
        // Returns:
        //     true if the evidence is locked; otherwise, false. The default is false.
        public bool Locked { get; set; }
        //
        // Summary:
        //     Gets the synchronization root.
        //
        // Returns:
        //     Always this (Me in Visual Basic), because synchronization of evidence sets
        //     is not supported.
        public object SyncRoot { get; set; }

        // Summary:
        //     Adds the specified assembly evidence to the evidence set.
        //
        // Parameters:
        //   id:
        //     Any evidence object.
        //
        // Exceptions:
        //   System.ArgumentNullException:
        //     id is null.
        //
        //   System.ArgumentException:
        //     id is not serializable.
        [Obsolete("This method is obsolete. Please use AddAssemblyEvidence instead.")]
        public void AddAssembly(object id){}
        //
        // Summary:
        //     Adds an evidence object of the specified type to the assembly-supplied evidence
        //     list.
        //
        // Parameters:
        //   evidence:
        //     The assembly evidence to add.
        //
        // Type parameters:
        //   T:
        //     The type of the object in evidence.
        //
        // Exceptions:
        //   System.ArgumentNullException:
        //     evidence is null.
        //
        //   System.InvalidOperationException:
        //     Evidence of type T is already in the list.
        //
        //   System.ArgumentException:
        //     evidence is not serializable.
        [ComVisible(false)]
        public void AddAssemblyEvidence<T>(T evidence) where T : EvidenceBase
        {
            
        }
        //
        // Summary:
        //     Adds the specified evidence supplied by the host to the evidence set.
        //
        // Parameters:
        //   id:
        //     Any evidence object.
        //
        // Exceptions:
        //   System.ArgumentNullException:
        //     id is null.
        //
        //   System.ArgumentException:
        //     id is not serializable.
        [Obsolete("This method is obsolete. Please use AddHostEvidence instead.")]
        [SecuritySafeCritical]
        public void AddHost(object id)
        {
            
        }
        //
        // Summary:
        //     Adds host evidence of the specified type to the host evidence collection.
        //
        // Parameters:
        //   evidence:
        //     The host evidence to add.
        //
        // Type parameters:
        //   T:
        //     The type of the object in evidence.
        //
        // Exceptions:
        //   System.ArgumentNullException:
        //     evidence is null.
        //
        //   System.InvalidOperationException:
        //     Evidence of type T is already in the list.
        [ComVisible(false)]
        public void AddHostEvidence<T>(T evidence) where T : EvidenceBase
        {
            
        }
        //
        // Summary:
        //     Removes the host and assembly evidence from the evidence set.
        [SecuritySafeCritical]
        [ComVisible(false)]
        public void Clear()
        {
            
        }
        //
        // Summary:
        //     Returns a duplicate copy of this evidence object.
        //
        // Returns:
        //     A duplicate copy of this evidence object.
        [ComVisible(false)]
        public Evidence Clone()
        {
            return (Evidence)MemberwiseClone();
        }
        //
        // Summary:
        //     Copies evidence objects to an System.Array.
        //
        // Parameters:
        //   array:
        //     The target array to which to copy evidence objects.
        //
        //   index:
        //     The zero-based position in the array to which to begin copying evidence objects.
        //
        // Exceptions:
        //   System.ArgumentNullException:
        //     array is null.
        //
        //   System.ArgumentOutOfRangeException:
        //     index is outside the range of the target array.
        [Obsolete("Evidence should not be treated as an ICollection. Please use the GetHostEnumerator and GetAssemblyEnumerator methods rather than using CopyTo.")]
        public void CopyTo(Array array, int index)
        {
            
        }
        //
        // Summary:
        //     Enumerates evidence provided by the assembly.
        //
        // Returns:
        //     An enumerator for evidence added by the System.Security.Policy.Evidence.AddAssembly(System.Object)
        //     method.
        public IEnumerator GetAssemblyEnumerator()
        {
            return null;
        }
        //
        // Summary:
        //     Gets assembly evidence of the specified type from the collection.
        //
        // Type parameters:
        //   T:
        //     The type of the evidence to get.
        //
        // Returns:
        //     Evidence of type T in the assembly evidence collection.
        [ComVisible(false)]
        public T GetAssemblyEvidence<T>() where T : EvidenceBase
        {
            return default(T);
        }
        //
        // Summary:
        //     Enumerates all evidence in the set, both that provided by the host and that
        //     provided by the assembly.
        //
        // Returns:
        //     An enumerator for evidence added by both the System.Security.Policy.Evidence.AddHost(System.Object)
        //     method and the System.Security.Policy.Evidence.AddAssembly(System.Object)
        //     method.
        [Obsolete("GetEnumerator is obsolete. Please use GetAssemblyEnumerator and GetHostEnumerator instead.")]
        public IEnumerator GetEnumerator()
        {
            return null;
        }
        //
        // Summary:
        //     Enumerates evidence supplied by the host.
        //
        // Returns:
        //     An enumerator for evidence added by the System.Security.Policy.Evidence.AddHost(System.Object)
        //     method.
        public IEnumerator GetHostEnumerator()
        {
            return null;
        }
        //
        // Summary:
        //     Gets host evidence of the specified type from the collection.
        //
        // Type parameters:
        //   T:
        //     The type of the evidence to get.
        //
        // Returns:
        //     Evidence of type T in the host evidence collection.
        [ComVisible(false)]
        public T GetHostEvidence<T>() where T : EvidenceBase
        {
            return default(T);
        }
        //
        // Summary:
        //     Merges the specified evidence set into the current evidence set.
        //
        // Parameters:
        //   evidence:
        //     The evidence set to be merged into the current evidence set.
        //
        // Exceptions:
        //   System.ArgumentException:
        //     The evidence parameter is not a valid instance of System.Security.Policy.Evidence.
        //
        //   System.Security.SecurityException:
        //     System.Security.Policy.Evidence.Locked is true, the code that calls this
        //     method does not have System.Security.Permissions.SecurityPermissionFlag.ControlEvidence,
        //     and the evidence parameter has a host list that is not empty.
        [SecuritySafeCritical]
        public void Merge(Evidence evidence)
        {
            
        }
        //
        // Summary:
        //     Removes the evidence for a given type from the host and assembly enumerations.
        //
        // Parameters:
        //   t:
        //     The type of the evidence to be removed.
        //
        // Exceptions:
        //   System.ArgumentNullException:
        //     t is null.
        [ComVisible(false)]
        [SecuritySafeCritical]
        public void RemoveType(Type t)
        {
            
        }
    }
}
